Method and apparatus for performing hash lookups using valid bit tables with pointers

ABSTRACT

A method, apparatus, and article of manufacture for hash lookups using valid bit tables with pointers. A key is compressed by hashing the key using a hash function. The hash key is used as a valid bit index into the valid bit table. A first pointer associated with the valid bit index is then used as a pointer into a first block of entries in a result table. A sum of transition bits in the valid bit table below the valid bit index is used as a result index into the first block of entries in the result table. The result index into the first block of entries may be used to reference a result of the radix search tree lookup. Extra space is added in the result table to enable insertion of entries after the first block of entries. A second pointer is used to add redundant entries from the first block of entries into a second block of entries in the result table.

FIELD OF THE INVENTION

This invention relates generally to data communications networks, andmore particularly, to a method and apparatus for performing hash lookupsusing valid bit tables with pointers.

BACKGROUND OF THE INVENTION

There are numerous known methods for searching for data in a datastructure stored in a memory of a computer system to find a particularitem of information. It is desirable to implement methods for organizingand searching for data in the data structure in a way that reduces theamount of memory required to store the data and perform the search in amore efficient manner.

A table or a file is a group of data elements, each of which may becalled an entry or a record in the table. Generally, a key is associatedwith each record. The key is used to differentiate among differentrecords. The key associated with a particular record may or may not needto be unique, depending on the search method utilized in accessing thetable. In addition, the key may or may not be embedded within the recorditself.

A search method accepts a key value as input and attempts to locate arecord within a table stored in the memory of a computer system whoseassociated key is the key value. The search method may return a record,or a pointer to the record. The contents of the record may be data,program code, or a pointer to either data or program code. If the searchof a table is unsuccessful in finding the key, then there is no recordin the table associated with the key value. Typically, if the search isunsuccessful, an insertion is performed to add a new record with the keyvalue as its key.

A table is stored in a data structure in the memory or an externalstorage, e.g., magnetic disk, of a computer system. The form of the datastructure may be an array of records, a tree, a linked list, etc.Certain search methods are generally more applicable to one form andlocation of a data structure than another. Thus, the data structure inwhich a table is stored is, in part, selected according to the searchmethod to be used to access information within the table. The presentinvention is related to search operations on a file or table that isorganized as a tree structure.

One known search method utilizes a tree to facilitate searching a tablestored in the memory of a computer system. This search method forms atree based on symbols of which the keys are comprised. This is generallyreferred to as a radix search tree. For example, if the key is comprisedof the hexadecimal characters 0 through F, each successive hexadecimaldigit position in the key determines 1 of 16 possible children of agiven node in the tree.

When the set of keys in a table is sparse, known methods of storing atable of keys in a tree for later radix searching wastes a large amountof memory space. Therefore, there is a need for a way of storinginformation in a tree structure in the memory of a computer system andfor subsequently searching the tree such that the amount of memoryrequired to store a sparse table of keys is minimized. There is afurther need for searching a tree in the memory of a computer system ina fast, efficient manner.

SUMMARY OF THE INVENTION

The present invention provides a method, apparatus, and article ofmanufacture for hash lookups using valid bit tables with pointers. A keyis compressed by hashing the key using a hash function. The hash key isused as a valid bit index into the valid bit table. A first pointerassociated with the valid bit index is then used as a pointer into afirst block of entries in a result table. A sum of transition bits inthe valid bit table below the valid bit index is used as a result indexinto the first block of entries in the result table. The result indexinto the first block of entries may be used to reference a result of theradix search tree lookup. Extra space is added in the result table toenable insertion of entries after the first block of entries. A secondpointer is used to add redundant entries from the first block of entriesinto a second block of entries in the result table.

BRIEF DESCRIPTION OF THE DRAWINGS

The present invention is illustrated by way of example and may be betterunderstood by referring to the following description in conjunction withthe accompanying drawings, in which like references indicate similarelements and in which:

FIG. 1 is a system diagram which shows a computer hardware environmentcompatible with the present invention;

FIG. 2 shows a simple radix lookup compatible with the presentinvention;

FIG. 3 shows a simple radix lookup with valid bit table compatible withthe present invention;

FIG. 4 shows a valid bit table with compressed result table compatiblewith the present invention;

FIG. 5 shows a 64 Kbit valid bit table with count compatible with thepresent invention;

FIG. 6 shows a 64 Kbit valid bit table with pointers compatible with thepresent invention;

FIG. 7 shows a valid bit table with hashing compatible with the presentinvention;

FIG. 8 shows a transition bit table example compatible with the presentinvention;

FIG. 9 shows a transition table representing single entry rangescompatible with the present invention;

FIG. 10 shows a 64 Kbit transition bit table with pointers with forcedadjacencies compatible with the present invention;

FIG. 11 shows a 64 Kbit transition bit table with pointers withredundant entries compatible with the present invention;

FIG. 12 shows a block diagram of a hardware implementation compatiblewith the present invention;

FIG. 13 shows a block diagram of a hardware implementation of a 64 Kbitvalid bit table followed by radix 16 tables compatible with the presentinvention;

FIG. 14 shows a compressed radix with transition field format compatiblewith the present invention;

FIG. 15 shows a compressed radix tree with transition field examplecompatible with the present invention;

FIG. 16 illustrates an example lookup using a key of 0×41 and the tableof FIG. 15;

FIG. 17 shows a 64 Kbit valid bit table followed by radix 256 tablescompatible with the present invention.

DETAILED DESCRIPTION OF A PREFERRED EMBODIMENT OF THE PRESENT INVENTION

In the following description of a preferred embodiment, reference ismade to the accompanying drawings which form a part hereof, and in whichis shown by way of illustration a specific embodiment in which theinvention may be practiced. It is to be understood that otherembodiments may be utilized and structural changes may be made withoutdeparting from the scope of the present invention. A preferredembodiment of the present invention, described below, enables a remotecomputer system user to execute a software application on a network fileserver.

Hardware Environment

FIG. 1 shows a computer hardware environment that could be used with thepresent invention. The present invention is typically implemented usinga computer 100, wherein the computer 100 comprises a processor 106,random access memory (RAM) 130, and read-only memory (ROM) and/or othercomponents. The computer 100 may be coupled to I/O devices, such as amonitor 102, keyboard 108, mouse device 110, fixed and/or removable datastorage devices 112 and 114, and printer 118. The computer 100 couldalso be coupled to other I/O devices, including a local area network(LAN) or wide area network (WAN) via interface cable 120. Those ofordinary skill in the art will recognize that any combination of theabove components, or any number of different components, peripherals,and other devices, may be used with the computer 100.

Generally, the computer 100 operates under control of an operatingsystem 122, which is represented by the display 104 on the monitor 102.The present invention is preferably implemented using one or morecomputer programs or applications 124, which are represented by thewindow displayed on the monitor 102 operating under the control of theoperating system 122. The operating system 122 and computer program 124are loaded from a data storage devices 112 and/or 114 into the memory130 of the computer 100 for use during actual operations.

In the preferred embodiment of the present invention, the operatingsystem 122 and the computer program 124 are useably embodied in acomputer-readable medium, e.g., data storage devices 112 and/or 114which could include one or more fixed or removable data storage devices,such as a floppy disk drive, hard drive, CD-ROM drive, tape drive, etc.Further, the operating system 122 and the computer program 124 arecomprised of instructions which, when read and executed by the computer100, causes the computer 100 to perform the steps necessary to implementand/or use the present invention. Those of ordinary skill in the artwill recognize that many modifications may be made to thisconfiguration, including the number, size, and types of components,without departing from the scope of the present invention.

In the following description, for purposes of explanation, numerousspecific details are set forth in order to provide a thoroughunderstanding of the present invention. It will be evident, however, toone skilled in the art that the present invention may be practicedwithout these specific details. In other instances, well-knownstructures and devices are shown in block diagram form in order tofacilitate description.

In one embodiment, steps according to the present invention are embodiedin machine-executable software instructions, and the present inventionis carried out in a processing system by a processor executing theinstructions, as will be described in greater detail below. In otherembodiments, hardwired circuitry may be used in place of, or incombination with, software instructions to implement the presentinvention.

Valid Bit Tables

A radix lookup uses a key or pieces of a key as an address into a table,as shown in FIG. 2. For example, if a 16 bit key were being looked up, a64K entry table of results would be referenced by the entire key. Thevalue in the table is the result of the lookup.

If the desired result is large, the result table can become quite large.This becomes especially wasteful if the table is sparsely populated. Ifthis is the case, it is desirable to shrink the size of the resultentries.

In a valid bit table, the only result is if the entry is valid or not,as shown in FIG. 3. A single bit is sufficient to do this. In this case,the result table would have 64K entries and each entry would be a bit.The bit would be referenced with the key as before and the result wouldindicate if the key were valid or not.

The valid bit table wastes very little space on invalid results becauseonly a single bit is used, but does not provide a large result for validentries. To improve on this, an additional table can be added that onlycontains the results for valid entries, as shown in FIG. 4. Validentries are accessed in the following manner. The result table containsas many entries as there are valid results. An entry that is at locationN in the result table is associated with the valid bit that is the Nthvalid bit in the bit table. To determine the location of a result givena valid bit, the valid bits from N−1 to 0 must be summed. For example,in an 8 entry bit table with 3 valid results corresponding to a key of2, 5 and 7, a key of 7 would result in the bit table being referenced atbit 7. The fact that bit 7 is set indicates the entry is valid and theresult is available. Bit 7 is the third valid bit that is set. Theresult for bit 7 must be the third entry in the result table at location2, counting addresses from 0. The value 2 is computed by summing all thevalid bits below the valid bit selected.

This method can be extended to large bit strings as in the previousexample. The problem then becomes that the summation of all the validbits below the bit selected may require a large number of memoryaccesses. This problem can be solved by keeping a count along with thebit string at even intervals that records the number of valid entries tothat point, as shown in FIG. 5. The address of the result is then thesum of the count plus the number of one's beyond the count but below thebit selected. An example of this is a 64 Kbit string with count valuesevery 16 bits. The count value must be at most 16 bits long to cover thepossible 64 Kbit results. This is shown pictorially in FIG. 5, which forconvenience, shows the bit field rotated.

In the example shown in FIG. 5, N is the count value of the bit fieldabove it. N is the count or sum of all the valid entries to the left ofthe segment. The result entry is then the count field plus the bits inthe selected bit field segment that are to the left of the selected bit.The sizes of 16 bits of valid and a 16 bit offset are not required. Thecount must be large enough to account for the maximum number of results.The bit field associated with the count may be as large as convenient.16 bits is convenient because both the field and the count can be readin a single 32-bit memory reference.

The result arrangement described above provides for the efficient use ofmemory. It is effective in tables with a large number of entries sincethere is a fixed overhead associated with the bit field and countrepresentation. One problem with this type of arrangement is thedifficulty in adding or removing entries from the table. Adding an entryto the beginning of the table would force all of the counts after theaddition to be incremented by one. One way of improving this is toreplace the count by a simple pointer, as shown in FIG. 6. The pointerpoints to a block of memory allocated for that pointer/bit field. Theblock is at least as large as the number of valid entries associatedwith that bit field. For example, if a pointer/bit field had a bit fieldthat was 01001001001000101 which has 6 valid results, the pointer wouldpoint to a block of 6 consecutive entries in the result table. To allowfor adding and deleting entries, space is allocated between theseblocks. The fact that a pointer is used, rather than a count, is whatallows space to be added between blocks. Because a pointer is used, theresult blocks may be placed anywhere in the result table.

Valid Bit Tables With Hashing

Hashing may also be used for performing lookups. In hashing, the key iscompressed by using a hash function and the compressed value is thenused to reference a table of results, as shown in FIG. 7. Included inthe result is a bit indicating the result is valid and a full copy ofthe key the entry represents. The key is required in the result becausethe compression may result in multiple keys hashing to the samelocation. To reduce the chance of hashing to the same location, hashtables are typically larger than the number of results. A result tablethat is three times larger than the number of results is typical. Evenlarger tables would further reduce the chance of collisions.

Valid bit tables can be used to reduce the required storage of hashresults. This is accomplished by replacing the normal key with acompressed key. No other changes are required. The selected result mustinclude a full key to compare against the original key.

Transition Bit Tables

The ability to represent ranges within a table is useful inpacket-switched networking applications. The valid bit method describedabove does not represent ranges very well. For example, if a range of0×4560 to 0×456f were represented with the valid bit scheme, it wouldrequire 16 duplicate entries in the result table, one for 0×4560, onefor 0×4561 and so on.

An improvement on this method represents transitions in the bit fieldrather than valid or invalid entries, as shown in FIG. 8. A one in thebit field indicates the end of a range rather than a single valid entry.The mechanics of computing the address of the result corresponding tothe range are nearly the same as the case of the valid bit tables.Because a one in the bit field indicates the end of a range, this alsoindicates a transition to a new result. The offset of a result is thenobtained by summing the number of 1's to the left, or the leastsignificant bits (LSB), of the selected bit. This is the same process asused with valid bits. The only difference is that in a transition bittable, there is no “invalid” entry, every range has a result, even ifthe result will indicate the range is invalid. An example is shown inFIG. 8. In the example, three ranges are represented, 0-2, 3-5, 6-7. Akey of 7 would result in the transition field being referenced at bit 7.The transition bits over the range 0-6 in the transition bit table aresummed to provide the offset of 2, counting from 0, into the resulttable. FIG. 9 shows an example of how a transition table represents arange of one as indicated by the ranges 0—0, 1—1, 2—2, and 3—3.

As with the valid bit tables, the transition bit tables can be used torepresent larger tables. As with the methods described above, thiscreates a need for an additional count field to prevent the need to sumall bits below the selected bit. Transition tables also suffer from theproblem that the table is difficult to update because all the countfields above a new or deleted entry must be adjusted when makingchanges. This problem can be alleviated by using pointers rather thancounts, as shown in FIG. 10.

Using pointers in a transition table is not quite as effective as is thecase in the valid bit tables, because unlike a valid bit table, theleading zero's in a transition bit table have a result. The result isthe same result as any trailing zero's in the previous field. Thisforces the pointer in the second field to point to the trailing entry inthe result table of the first field and eliminates the ability to addempty space between entries.

The inability to add empty space between entries may be corrected byadding additional redundant entries when separating two regions withshared results, as shown in FIG. 11. While this requires additionalmemory, the benefits gained by allowing easy insertion and deletion aretypically considered acceptable by system designers.

Hardware Implementation

One key to the efficient implementation of the present invention is theability to quickly sum all the bits in a field left of the selected bit.The example shown in FIG. 12 demonstrates the method for a 4 bit key and16 bit field. It will be recognized by one of ordinary skill in the artthat this method can be applied to any n bit key and 2**n bit field. Forvalid bit tables, the bit selected by the key must be checked. If thebit is set, it is a valid entry. If the bit is not set, the entry isinvalid and no further work is required. Transition bit tables do notperform this check. The key is used to generate a mask. The maskgenerated has all the bits set to one which are less significant thanthe bit selected by the key. For example, if the key were 5, the maskgenerated would be 11111000000000000, where the LSB is on the left. Themask and the bit field are bitwise ANDed together which produces a valuewith only those bits less significant than the selected bit set. Thesebits are summed to produce the desired result.

Key Lookup

The present invention provides a means for performing a lookup of a keywith a single access into a valid or transition bit field. The table canrepresent valid entries or ranges. While this technique is useful, asthe size of the key grows, the amount of memory required becomes quitelarge and the method becomes increasingly inefficient. For example, atable sufficient for a 16 bit key would require 16 Kbytes of memory forthe bit field and the result pointer. If this were used to represent thefirst 16 bits of lookup on a typical Internet IPv4 table with 40000entries, this would provide an efficiency of 1.2 bits of memory per bitof key represented. If the lookup were extended to 20 bits, theefficiency drops to 32 bits of memory per bit of key represented. Adifferent mechanism must therefore be used to perform lookups for largerkeys.

A fast and efficient compressed radix lookup mechanism may be used withvalid bit fields and transition fields. The basic approach is to startthe lookup with a large bit field lookup, either valid or transitiontype, and follow it with lookups with smaller granularity. This isrequired because the top of a lookup tree is much more dense than thebottom. A reasonable approach is to start with a 16 bit lookup andfollow it with several smaller lookups.

A radix 16 or compressed radix approach may be used in conjunction withthe valid bit approach described above, as shown in FIG. 13. The searchbegins with a large radix lookup, 64K for example. The results of thatlookup are additional radix 16 lookups. It will be recognized by one ofordinary skill in the art that other radix can be used, with radix 8, 32and 64 being reasonably efficient when implemented as compressed radixtrees.

In the example shown in FIG. 13, the first 16 bits of the key are usedto reference the 64K valid bit table. In the associated result table,the result entries are compressed radix 16 entries that continue thelookup of bits 16 to 19 of the key. The remaining 4 bits are looked upin another compressed radix 16 entry in another piece of memory.

Compressed Radix With Transition Fields

The valid bit representation of compressed radix tables may also be usedwith transition bits. The compressed radix with transition fields formatis useful in representing ranges, as shown in FIG. 14. Each entry intothe compressed radix table in this case has a continue/vector bit, apointer to a next vector or a result block, and a transition field torepresent of range as illustrated in FIG. 14. The use of this compressedradix format is similar to that described above with the exception ofthe transition field. FIG. 15 shows an example illustrating howtransition fields can be used on tables for compressed radix trees torepresent ranges. The example represents three ranges:

1. 0×00-0×22 with a result of A.

2. 0×23-0×45 with a result of B.

3. 0×46-0×FF with a result of C

FIG. 16 shows an example of a compressed radix lookup into the table ofFIG. 15 using a key of 0×41. The first nibble of the key, being a 4,selects the bit position labeled 4 in the transition field. Thetransition bits to the left of the selected bit position (i.e. the lowerorder bit positions labeled 0-3 in FIG. 16) are summed up to obtain avalue of 3. The next entry into the table is determined by adding thepointer 1 and the summation value of 3 together. This next entry has itsContinue/Vector bit set to a C to indicate a continuation in the lookupsequence a pointer 3 in its pointer field. The second nibble of the key,being a 1, selects the bit position labeled 1 in the transition field.The transition bits to the left of the selected bit position (i.e. thelower order bit position labeled 0 in FIG. 16) is summed up to obtain avalue of 0. The next entry into the table is determined by adding thepointer 3 and the summation value of 0 together. This next entry has itsContinue/Vector bit set to a V to indicate this is the end of the searchor lookup and its pointer field returns the result of B. Most networktables must represent both specific values and ranges of values. Thetransition field representation is typically not the most efficient wayof representing specific values as each value will require at least tworesults, one for the value and one for not the value. In light of this,a preferred embodiment of the present invention is able to support boththe valid and transition field representations. Differentiating betweenthe two can be accomplished with an additional bit in the entryindicating the type of entry it is, or segmenting memory and using thelocation in memory as an indication of the entry type.

Another method of representing both types of entries is to double thesize of the transition bit field to allow two bits per transition. Inthis case, the bits can be encoded to mean

invalid entry

start or middle of range

valid entry

end of range.

The advantage of this encoding is that invalid entries do not need to berepresented in the corresponding result block. An effect of thisencoding is that it double the size of the transition field.

Larger Radix Searches

Another possible way of continuing the searches is simply to use thevalid/transition bit tables described above with smaller radix values,as shown in FIG. 17. For example, a system could start with a radix 64 klookup (16 bit key) followed by a radix 256 (8 bit) lookup. The problemwith this approach is that some 256 bit field may only represent onerange. The memory efficiency in this case is quite low. A 256 bit fieldwith associated pointers will require 64 bytes of memory. To reach theefficiency of the compressed radix 16 tables which has a maximum of 8bits per bit, a radix 256 table must represent 8 entries, which is 8bits of key *8 keys in 64 bytes of memory.

One method of using the longer radix tables in continuing lookupsrequires three memory references for a 24 bit key, as shown in FIG. 17.In this example, the first 16 bits of the key are used to reference a64K valid/transition bit table. The result is a pointer to the beginningof a 256 bit valid/transition bit table. This table is then referencedto lookup the remaining 8 bits of the key. The result of this lookup isthe result of the overall lookup. This takes three memory references toresolve the lookup, with one additional memory reference required toread the result: the first memory reference is used for the 16 bit validfield and associated pointer, the second memory reference is used forthe first result table, the third memory reference is used to referencethe valid field and pointer in the 256 bit table, and the fourth memoryreference reads the result.

While the invention is described in terms of preferred embodiments in aspecific system environment, those of ordinary skill in the art willrecognize that the invention can be practiced, with modification, inother and different hardware and software environments within the spiritand scope of the appended claims.

What is claimed is:
 1. A method for performing a hash lookup on a radixsearch tree of a data structure stored in a computer to obtain a result,the method comprising: hashing a key using a hash function to generate ahash key; using the hash key as a valid bit index into a valid bittable; using a first pointer associated with the valid bit index as apointer into a first block of entries in a result table; and using a sumof valid bits in the valid bit table below the valid bit index todetermine a result index into the first block of entries in the resulttable.
 2. The method of claim 1 further comprising: using the resultindex into the first block of entries to reference the result of thehash lookup.
 3. The method of claim 2 wherein, the result of the hashlookup includes a full copy of the key.
 4. The method of claim 3 furthercomprising: verifying the result of the hash lookup is a final result bycomparing the key with the full copy of the key in the result todetermine if they match.
 5. The method of claim 1 further comprising:adding space in the result table to enable insertion of entries afterthe first block of entries.
 6. The method of claim 1 further comprising:using a second pointer to add an entry from the first block of entriesin the result table into a second block of entries in the result table.7. The method of claim 1 wherein, the sum of valid bits in the valid bittable below the valid bit index is computed using a counter.
 8. Themethod of claim 1 wherein, the valid bits in the valid bit tableindicate valid search entries for a hash key.
 9. The method of claim 1wherein, a value of the hash key differentiates one or more entries inthe valid bit table.
 10. The method of claim 1 wherein, a time toperform the lookup is reduced by using the hash key.
 11. An apparatusfor performing a hash lookup on a radix search tree of a data structurestored in a digital computer to obtain a result, the apparatuscomprising: the digital computer having an input device and a processor,the input device to receive a key into the digital computer; theprocessor to generate a hash key by hashing the key using a hashfunction; the processor to use the hash key as a valid bit index into avalid bit table; the processor to use a first pointer associated withthe valid bit index as a pointer into a first block of entries in aresult table; and the processor to sum valid bits in the valid bit tablebelow the valid bit index, the sum providing a result index into thefirst block of entries in the result table.
 12. The apparatus of claim11 further comprising: the processor to use the result index into thefirst block of entries in the result table to reference the result ofthe radix search tree lookup.
 13. The apparatus of claim 12 wherein, theresult of the hash lookup includes a full copy of the key.
 14. Theapparatus of claim 13 wherein, the processor further to verify theresult of the hash lookup is a final result by comparing the key withthe full copy of the key in the result to determine if they match. 15.The apparatus of claim 11 further comprising: the processor to add spacein the result table to enable insertion of entries after the first blockof entries.
 16. The apparatus of claim 11 further comprising: theprocessor to use a second pointer to add an entry from the first blockof entries in the result table into a second block of entries in theresult table.
 17. An article of manufacture for use in a computer systemfor performing a hash lookup on a radix search tree of a data structurestored in a digital computer to obtain a result, the article ofmanufacture comprising: a computer usable medium having computerreadable program code means embodied in the medium, the computerreadable program code means to hash a key using a hash function togenerate a hash key; use the hash key as a valid bit index into thevalid bit table; use a first pointer associated with the valid bit indexas a pointer into a first block of entries in a result table; and use asum of valid bits in the valid bit table below the valid bit index as aresult index into the first block of entries in the result table. 18.The article of manufacture of claim 17 further comprising: meansembodied in the computer usable medium for causing a computer to use theresult index into the first block of entries to reference a result ofthe radix search tree lookup.
 19. The article of manufacture of claim 18wherein, the result of the hash lookup includes a full copy of the key.20. The article of manufacture of claim 19 wherein, the computerreadable program code further to verify the result of the hash lookup isa final result by comparing the key with the full copy of the key in theresult to determine if they match.
 21. The article of manufacture ofclaim 17 further comprising: means embodied in the computer usablemedium for causing a computer to add space in the result table to enableinsertion of entries after the first block of entries.
 22. The articleof manufacture of claim 17 further comprising: means embodied in thecomputer usable medium for causing a computer to use a second pointer toadd an entry from the first block of entries in the result table into asecond block of entries in the result table.
 23. A method of efficientlysearching in performing a lookup on a data structure stored in acomputer, the method comprising: providing a valid bit table and a hashresult table of a radix search tree in the computer for the datastructure; accepting a search key, hashing the search key into a hashkey using a hash function, the hash key a valid bit index into the validbit table; computing a sum of valid bits in the valid bit table belowthe valid bit index of the hash key, the sum of valid bits a resultindex into the hash result table; using the result index to reference aresult of the lookup in the hash result table; and verifying the resultis a final result by comparing the search key with a full key stored inthe result.
 24. The method of claim 23 wherein, the valid bits in thevalid bit table indicate valid search entries for the hash key.
 25. Themethod of claim 23 wherein, a value of the hash key differentiates oneor more entries in the valid bit table.